Спринт 2/18 → Тема 6/6: Основы отладки программ → Урок 2/3

Охотник за багами: The Python Debugger

В Python «из коробки» встроена интерактивная среда отладки программ — The Python Debugger (pdb). Этот инструмент позволяет приостановить работу программы в указанном месте и продолжить выполнение кода построчно, используя терминал. Так разработчик может проверить работоспособность каждой строчки кода и найти те места в программе, которые приводят к неожиданному результату.

У отладчика pdb весьма обширный функционал, подробно он описан в документации. Сейчас вам не понадобятся все его возможности, достаточно будет разобраться в том, как выполнить программу пошагово, чтобы найти причины ошибок.

Начинаем дебажить

Откройте в редакторе кода проект calc_and_win и активируйте виртуальное окружение, если ещё не сделали этого.

Запустите файл main.py. Для этого в терминале выполните команду:

BASH

# На Windows:
python -m pdb main.py

# На Linux/MacOS:
python3 -m pdb main.py

Отладчик запустит файл и остановит выполнение кода на первой строке; в терминале появится приглашение для ввода команд отладчика — это строка, которая начинается с идентификатора (pdb):

В режиме отладки (или дебага) используются специальные команды для управления ходом выполнения программы. Вот описание основных команд:

h (help) — вывести все доступные команды pdb.
l (list) — вывести в терминал по пять строк до и после строки, на которую интерпретатор указывает в данный момент.
s (step) — выполнить строку, на которую указывает интерпретатор в данный момент, и остановить выполнение программы на следующей строке, если это возможно.
n (next) — эта команда очень похожа на команду step, но она будет выполнять программу не строго по шагам. Команда next не станет заходить внутрь функций, а выполнит их целиком, в один шаг.
b (break) имя_файла:номер_строки — указать место обязательной остановки выполнения программы. Место обязательной остановки программы разработчики называют «точка останова» или «брейкпоинт».
c (continue) — выполнять программу до тех пор, пока она не отработает полностью или пока её выполнение не будет прервано ошибкой. Также выполнение этой команды будет прервано достижением точки останова — брейкпоинта.
p имя_переменной — вывести текущее значение переменной в терминал.
q (quit) — остановить работу отладчика.

В запущенном отладчике введите команду c. Программа начнёт выполняться и остановится, как только упрётся в ошибку:

Подобный трейсбек вы уже видели в прошлом уроке, сейчас ваша задача — найти и устранить причину его появления.

Выведите в терминал участок кода с ошибкой, для этого выполните команду l:

Символ –> указывает на строку, на которой программа перестала выполняться. Эта строка отвечает за вывод сообщения о том, что в игре нет введённой команды. Но как так? Ведь мы ввели именно то, что просила программа!

Воспользуйтесь командой p и посмотрите, что в данный момент выполнения программы хранится в переменной replay и коллекции yes_no.

В переменной replay пусто, а yes_no — это список со значениями ['y', 'n'].

yes_no — это словарь, а переменная replay должна содержать как минимум то, что вы ввели до того, как возникла ошибка (y или n).

В переменной replay содержится строка 'y' или 'n', а yes_no — это словарь со значениями ['y': True, 'n': False].

Содержимое переменной верное, коллекция yes_no — это действительно словарь, но вот значения словаря другие.

В переменной replay содержится строка 'y' или 'n', а yes_no — это словарь со значениями ['Y': True, 'N': False].

А вот и причина ошибки! Значение переменной replay не совпадает ни с одним значением словаря yes_no. Помните — Python чувствителен к регистру.

Причина ошибки в том, что программа требует не тот набор значений, который задан в ключах словаря.

Чтобы избавиться от ошибки, нужно расширить словарь yes_no. Остановите работу отладчика, поправьте и сохраните код в файле module.py:

PYTHON
def run_game():
    ...
    yes_no = {
        'Y': True,
        'N': False,
        # Новые значения словаря.
        'y': True,
        'n': False,
    }
    ... 

Снова запустите программу в режиме отладчика и дайте команду выполнять программу до тех пор, пока она не отработает полностью или пока её выполнение не будет прервано ошибкой — введите команду c. Выполните пять атак противника в режиме отладчика и введите команду 'y', чтобы сыграть в игру ещё раз, или команду 'n', чтобы закончить игру и вернуться к отладке программы. Всё должно отработать без проблем.

Одна ошибка в программе исправлена, но есть ещё одна — в ходе тестирования игры было выявлено, что она неправильно считает количество очков урона, нанесённое противнику. Это логическая ошибка, интерпретатор не умеет находить такие ошибки. Значит, всё в ваших руках.

Ищем логическую ошибку

Чтобы найти логическую ошибку в чужом коде, можно пройти программу полностью, шаг за шагом. Но такой подход может занять много времени. Более подходящее решение — проанализировать код и результаты запуска программы перед началом отладки.

В файле main.py нет никаких расчётов, но к этому файлу подключена функция run_game() из модуля module.py. Можно сделать вывод, что искать неправильный расчёт нужно именно в функции run_game(). Функция run_game() вызывается внутри функции main() в файле main.py. Значит, первый шаг в процессе поиска истины — дойти в режиме дебаггинга до функции main() в файле main.py.

Запустите программу в режиме дебаггинга и воспользуйтесь командой n, чтобы не идти по шагам через все этапы импорта, до тех пор пока не дойдёте до строки с вызовом функции main(). Ваш путь должен быть таким:

BASH
# Запускаем файл main.py в режиме дебага.
$ python -m pdb main.py
# Отладчик переходит к первой строке файла.
> директория_проекта\main.py(1)<module>()
# Выводится строка, на которой находится отладчик.
-> from module import run_game
# Импорт — стандартная операция. Заглядывать внутрь этой операции
# нет необходимости. Выполняем команду n.
(Pdb) n
# Отладчик переходит к третьей строке.
> директория_проекта\main.py(3)<module>()
# Выводится строка, на которой находится отладчик. 
-> INTRO = '''РАССЧИТАЙ И ПОБЕДИ!...'''
# Тут можно использовать и команду s, и команду n, в любом случае
# отладчик сделает всего один шаг.
(Pdb) n
# Отладчик переходит к шестнадцатой строке.
> директория_проекта\main.py(16)<module>()
# Выводится строка, на которой находится отладчик. 
-> def main():
# Сейчас отладчик находится на шаге объявления функции main(). Заглядывать
# внутрь этого процесса не нужно, поэтому выполняем команду n.
(Pdb) n
# Отладчик переходит к строке 22.
> директория_проекта\main.py(22)<module>()
# Выводится строка, на которой находится отладчик.
-> if __name__ == '__main__':
# Отладчик находится на строке, с которой начинается проверка,
# что файл запущен как самостоятельная программа. Заглядывать внутрь
# этого процесса не нужно, поэтому выполняем команду n.
(Pdb) n
# Отладчик переходит к строке 23.
> директория_проекта\main.py(23)<module>()
# Выводится строка, на которой находится отладчик.
# Вот он — вызов функции main().
-> main()
(Pdb) 

Если бы вы видели этот код впервые, то вам было бы неизвестно, как работает подключённый модуль, поэтому далее лучше идти по шагам, чтобы ничего не упустить. Ваша задача — найти функцию, в которой неправильно считаются очки атаки.

Используя команду s, дойдите до того момента, когда программа предложит вам ввести тип атаки.

Вы дошли до места в программе, где пользователь начинает вводить тип атак. Значит, момент, где очки всех атак будут суммироваться, где-то рядом. Продолжайте дебажить программу по шагам; функции стандартной библиотеки можно выполнять целиком с помощью команды n. Ваш путь должен получиться таким:

BASH

# Программа просит ввести тип атаки, вводим, например, mid.
Введи тип атаки: mid
# Отладчик переходит к строке 37.
> директория_проекта\module.py(37)get_user_attack()
# Выводится строка, на которой находится отладчик.
-> attack_value = attacks_types[input_attack]()
# Выполняем шаг.
(Pdb) s
# Отладчик обозначает вызов функции.
--Call--
# Отладчик переходит к строке 12.
> директория_проекта\module.py(12)get_mid_attack()
# Выводится строка, на которой находится отладчик.
-> def get_mid_attack():
# Выполняем шаг.
(Pdb) s
# Отладчик переходит к строке 13.
> директория_проекта\module.py(13)get_mid_attack()
# Выводится строка, на которой находится отладчик.
-> return randint(15, 25)
# randit — модуль стандартной библиотеки. Заглядывать внутрь него не нужно,
# он точно отрабатает отлично. Поэтому используем команду n.
(Pdb) n
# Отладчик сигнализирует, что функция вернула значение.
--Return--
# Отладчик останется на строке 13 и укажет возвращаемое значение.
> директория_проекта\module.py(13)get_mid_attack()->20
# Выводится строка, на которой находится отладчик.
-> return randint(15, 25)
# После ввода команды s отладчик завершит выполнение функции.
(Pdb) s
# Отладчик останется на строке 38.
> директория_проекта\module.py(38)get_user_attack()
# Выводится строка, на которой находится отладчик.
-> print(f'Количество очков твоей атаки: {attack_value}.')
# Делаем шаг, чтобы напечатать строку.
(Pdb) s
# Выводится строка.
Количество очков твоей атаки: 20.
# Отладчик остаётся на строке 39.
> директория_проекта\module.py(39)get_user_attack()
# Выводится строка, на которой находится отладчик.
-> total += 1 

Итак, пользователь выполнил атаку, и в переменную attack_value записалось случайное значение. Далее это случайное значение должно прибавиться к переменной total, в которой суммируются все очки атак. Но мы видим другую картину: вместо значения, полученного в attack_value, к переменной total добавляется единица.

Ошибка обнаружена! Но не будем спешить с её обезвреживанием. Мы прошли ещё не по всем путям её поиска.

Брейкпоинты: короткий путь к ошибке

Можно не проходить всю программу по шагам. Для этого существуют брейкпоинты — места обязательной остановки программы. До брейкпоинта программа будет выполняться в обычном режиме, что поможет сэкономить время.

Брейкпоинты лучше всего устанавливать как можно ближе к месту возможной ошибки. Вы уже знаете, что в тестируемой вами игре ошибка возникает в функции get_user_attack() — значит, лучшим выбором места для брейкпоинта будет строка, где происходит вызов этой функции.

Остановите отладчик, запустите его снова и установите брейкпоинт на строке, в которой происходит вызов функции get_user_attack():

BASH

$ python -m pdb main.py
> d:\dev\course\study_project_oop\debug_test\main.py(1)<module>()
-> from module import run_game
# Устанавливаем брейкпоинт: b имя_файла.py:номер_строки.
(Pdb) b module.py:44
Breakpoint 1 at d:\dev\course\study_project_oop\debug_test\module.py:44

Введите команду c: до брейкпоинта программа выполнится в обычном режиме.

BASH

(Pdb) c
РАССЧИТАЙ И ПОБЕДИ!
Загрузка...

Твоя цель — за 5 ходов набрать такое количество очков урона противнику,
которое попадет в диапазон +– 10 от значения здоровья противника.

Значение здоровья противника генерируется случайным образом
в диапазоне от 80 до 120 очков.

В твоём распоряжении три вида атак:
lite — урон от 2 до 5 очков;
mid — урон от 15 до 25 очков;
hard — урон от 30 до 40 очков.
ВПЕРЁД К ПОБЕДЕ!!!

> d:\dev\course\study_project_oop\debug_test\module.py(44)run_game()
-> user_total_attack = get_user_attack()
(Pdb)

Вот она — «проблемная» функция. Далее лучше идти по шагам, чтобы ничего не упустить — и вы придёте к ошибке, которую уже обнаружили ранее.

Пора бы её уже и исправить, но потерпите ещё немного. Есть ещё один способ добраться до ошибок в коде — используя интерфейс редактора кода, например VSCode.